const { response, batches: mockProjectFailedEmails } = await waitForFailedEmailsDigest(2);
      expect(response.status).toBe(200);

      if (process.env.STACK_TEST_SOURCE_OF_TRUTH === "true") {
      expect(mockProjectFailedEmails).toMatchInlineSnapshot(`[]`);
      } else {
      expect(mockProjectFailedEmails).toMatchInlineSnapshot(`

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@docker/dependencies/freestyle-mock/Dockerfile`:
- Around line 136-181: The `failInFlight` path clears slot.busy but doesn't mark
the slot draining, so a concurrent dispatch can claim a worker that's about to
exit; update the code so that `slot.draining = true` is set when a worker fails
(either inside `failInFlight` or immediately in the `worker.on("error", ...)`
handler before calling `failInFlight`), ensuring `dispatchNext()` will skip the
slot until the `exit` handler replaces it; refer to the `failInFlight` function,
the `worker.on("error", (err) => { ... })` handler, and the `slot.draining` flag
when making the change.
- Around line 258-261: The call to pool.run({ scriptFile, envVars }) can hang
forever if the user script never posts a message, so wrap/race the pool.run
promise with a timeout and on timeout forcefully terminate the associated worker
so the worker 'exit' handler can respawn it and clear slot.busy; specifically,
implement a timedRace around pool.run that rejects after a configurable TIMEOUT,
and on that rejection call the worker termination method used by the pool (so
the exit/cleanup logic that checks MAX_JOBS_PER_WORKER and clears slot.busy
runs), ensuring pool.run's rejection path also marks the slot free and surfaces
a clear timeout error to the caller.
- Around line 244-256: The npm install spawn block can hang because it lacks an
'error' listener, doesn't consume stdio pipes, and has no timeout; update the
logic around spawn("npm", ["install"], { cwd: workDir, stdio: "pipe" }) (used
when needsInstall && Object.keys(requestedNodeModules).length) to add
installProcess.on("error", ...) to reject immediately on spawn failures, pipe or
forward installProcess.stdout and installProcess.stderr to a logger or to
process.stdout/stderr to avoid filling OS buffers, implement a configurable
timeout timer that kills installProcess and rejects if install takes too long,
and ensure you clean up listeners and timer in the installProcess.on("close",
...) handler so the promise always resolves or rejects and doesn't leak
resources.

---

Nitpick comments:
In
`@apps/e2e/tests/backend/endpoints/api/v1/internal/failed-emails-digest.test.ts`:
- Around line 38-61: Update the comment above waitForFailedEmailsDigest to
explicitly state the single-batch assumption: note that the loop checks
batches[0]?.emails.length and therefore expects at most one batch per mailbox
(as used by selectBatchesForCurrentMailbox and the tests). Mention that if
multiple batches could be returned in the future the logic should be revised
(e.g., aggregate across batches or handle multiple indices) so maintainers know
why batches[0] is used.

In `@docker/dependencies/freestyle-mock/Dockerfile`:
- Around line 38-43: The captured logs currently stringify arguments with
args.map(String).join(" "), losing object/ Error detail; change the console
patch inside the logMethods.forEach to use Node's util.format so captured
messages match the unpatched console: require or import util.format (e.g. const
{ format } = require('util') or import { format } from 'util') and replace
args.map(String).join(" ") with format(...args) when calling logs.push({
message: ..., type: method }), keeping the originalConsole[method](...args) call
intact.

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Outside diff comments:
In `@docker/dependencies/freestyle-mock/Dockerfile`:
- Around line 45-66: The current snapshot logic only saves keys listed in
envVars (previousEnv) so any mutations/deletions to other process.env entries by
the user code leak across recycled workers; instead, capture a full copy of
process.env before importing/executing the user script (e.g., create a complete
snapshot object of process.env before the userModule import/execute around
scriptFile/userFunction) and in the finally block fully restore the environment
by removing keys added during execution and restoring original values from that
full snapshot (clear current process.env then reassign original keys), ensuring
the worker's environment is identical after each job.

---

Nitpick comments:
In `@docker/dependencies/freestyle-mock/Dockerfile`:
- Around line 87-103: The POOL_SIZE calculation uses cpus().length which ignores
cgroup limits; change it to prefer os.availableParallelism() when present and
fall back to cpus().length, then clamp with Math.max(2, ...). Update the code
that defines POOL_SIZE (the POOL_SIZE constant) to call availableParallelism()
safely (e.g., typeof availableParallelism === "function" ?
availableParallelism() : cpus().length) and keep the existing Math.max(2, ...)
clamp so the pool remains at least 2; reference the os import and the POOL_SIZE
constant to locate where to modify.